ReadBarcodes(RasterImage,LeadRect,int,BarcodeSymbology[],BarcodeReadOptions[]) Method

using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.Barcode; 
using Leadtools.ImageProcessing; 
 
 
// This class holds the data we will pass to each thread 
public class MyThreadData 
{ 
   // This worker thread name 
   public string Name; 
 
   // Barcode reader instance 
   public BarcodeReader BarcodeReaderInstance; 
 
   // Array of options to use 
   public BarcodeReadOptions[] ReadOptions; 
 
   // Image file containing the barcodes 
   public string ImageFileName; 
 
   // This will hold the barcodes found 
   public BarcodeData[] Barcodes; 
 
   // In case of errors 
   public Exception Error; 
 
   // Event to notify when the thread is finished 
   public ManualResetEvent FinishedEvent; 
} 
 
public void BarcodeReader_ReadBarcodeExample6() 
{ 
   string[] imageFileNames = PrepareImages(); 
 
   // Create a Barcode engine 
   BarcodeEngine engine = new BarcodeEngine(); 
 
   // Get the Barcode reader instance 
   BarcodeReader reader = engine.Reader; 
 
   // Get a version of all read options that support rotated barcodes 
   BarcodeReadOptions[] verticalBarcodeReadOptions = GetVerticalReadBarcodeOptions(reader); 
 
   // Synchronization events 
   ManualResetEvent[] finishedEvents = new ManualResetEvent[2]; 
 
   // Create the thread data objects 
   MyThreadData[] threadsData = new MyThreadData[2]; 
   for (int i = 0; i < threadsData.Length; i++) 
   { 
      finishedEvents[i] = new ManualResetEvent(false); 
 
      threadsData[i] = new MyThreadData(); 
      threadsData[i].BarcodeReaderInstance = reader; 
      threadsData[i].ReadOptions = null; 
      threadsData[i].FinishedEvent = finishedEvents[i]; 
   } 
 
   // Setup the read options for the two threads 
   threadsData[0].Name = "Read Default Options Thread"; 
   threadsData[0].ReadOptions = null;  // Default, or horizontal 
   threadsData[1].Name = "Read Vertical Barcodes Thread"; 
   threadsData[1].ReadOptions = verticalBarcodeReadOptions; 
 
   List<BarcodeData> totalBarcodes = new List<BarcodeData>(); 
 
   // Now loop through all the images and try to read the barcodes with both threads at the same time 
   foreach (string imageFileName in imageFileNames) 
   { 
      Console.WriteLine("Reading barcodes from {0}", imageFileName); 
 
      for (int i = 0; i < 2; i++) 
      { 
         // Clear the previous results (if any), set up the file name and run 
         threadsData[i].Barcodes = null; 
         threadsData[i].Error = null; 
         threadsData[i].ImageFileName = imageFileName; 
         ThreadPool.QueueUserWorkItem(new WaitCallback(ReadBarcodesInThread), threadsData[i]); 
      } 
 
      // Wait till all the threads finishes 
      foreach (ManualResetEvent waitHandle in finishedEvents) 
         waitHandle.WaitOne(); 
 
      // Add the barcodes found to our list 
      for (int i = 0; i < 2; i++) 
      { 
         if (threadsData[i].Error != null) 
         { 
            Console.WriteLine("{0} had error {1}", threadsData[i].Name, threadsData[i].Error); 
         } 
         else if (threadsData[i].Barcodes != null) 
         { 
            totalBarcodes.AddRange(threadsData[i].Barcodes); 
         } 
      } 
   } 
 
   // We are done, show the total number of barcodes read 
   Console.WriteLine("Done. Total barcodes read: {0}", totalBarcodes.Count); 
} 
 
private static void ReadBarcodesInThread(object state) 
{ 
   MyThreadData threadData = state as MyThreadData; 
 
   Console.WriteLine("{0} is reading the barcodes", threadData.Name); 
 
   try 
   { 
      // Load the image 
      using (RasterCodecs codecs = new RasterCodecs()) 
      { 
         using (RasterImage image = codecs.Load(threadData.ImageFileName, 0, CodecsLoadByteOrder.BgrOrGray, 1, 1)) 
         { 
            // Read the barcodes using our options 
            threadData.Barcodes = threadData.BarcodeReaderInstance.ReadBarcodes(image, LeadRect.Empty, 0, null, threadData.ReadOptions); 
         } 
      } 
 
      Console.WriteLine("{0} has read {1} barcodes", threadData.Name, threadData.Barcodes.Length); 
   } 
   catch (Exception ex) 
   { 
      // Return the error to main 
      threadData.Error = ex; 
   } 
   finally 
   { 
      // Tell main we are done 
      threadData.FinishedEvent.Set(); 
   } 
} 
 
private static string[] PrepareImages() 
{ 
   // Create a 90 degrees rotated version of Barcode1.tif 
 
   string originalImageFileName = Path.Combine(LEAD_VARS.ImagesDir, "Barcode1.tif"); 
   string rotatedImageFileName = Path.Combine(LEAD_VARS.ImagesDir, "Barcode1_Rotated90.tif"); 
 
   using (RasterCodecs codecs = new RasterCodecs()) 
   { 
      using (RasterImage image = codecs.Load(originalImageFileName, 0, CodecsLoadByteOrder.BgrOrGray, 1, 1)) 
      { 
         RotateCommand rotate = new RotateCommand(90 * 100, RotateCommandFlags.Resize, RasterColor.FromKnownColor(RasterKnownColor.White)); 
         rotate.Run(image); 
 
         codecs.Save(image, rotatedImageFileName, RasterImageFormat.CcittGroup4, 1); 
      } 
   } 
 
   return new string[] { originalImageFileName, rotatedImageFileName }; 
} 
 
private static BarcodeReadOptions[] GetVerticalReadBarcodeOptions(BarcodeReader reader) 
{ 
   // By default, the options read horizontal barcodes only, create an array of options capable of reading vertical barcodes 
 
   // Notice, we cloned the default options in reader so we will not change the original options 
 
   OneDBarcodeReadOptions oneDReadOptions = reader.GetDefaultOptions(BarcodeSymbology.UPCA).Clone() as OneDBarcodeReadOptions; 
   oneDReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   FourStateBarcodeReadOptions fourStateReadOptions = reader.GetDefaultOptions(BarcodeSymbology.USPS4State).Clone() as FourStateBarcodeReadOptions; 
   fourStateReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   PostNetPlanetBarcodeReadOptions postNetPlanetReadOptions = reader.GetDefaultOptions(BarcodeSymbology.PostNet).Clone() as PostNetPlanetBarcodeReadOptions; 
   postNetPlanetReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   GS1DatabarStackedBarcodeReadOptions gs1StackedReadOptions = reader.GetDefaultOptions(BarcodeSymbology.GS1DatabarStacked).Clone() as GS1DatabarStackedBarcodeReadOptions; 
   gs1StackedReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   PatchCodeBarcodeReadOptions patchCodeReadOptions = reader.GetDefaultOptions(BarcodeSymbology.PatchCode).Clone() as PatchCodeBarcodeReadOptions; 
   patchCodeReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   PDF417BarcodeReadOptions pdf417ReadOptions = reader.GetDefaultOptions(BarcodeSymbology.PDF417).Clone() as PDF417BarcodeReadOptions; 
   pdf417ReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   MicroPDF417BarcodeReadOptions microPdf417ReadOptions = reader.GetDefaultOptions(BarcodeSymbology.MicroPDF417).Clone() as MicroPDF417BarcodeReadOptions; 
   microPdf417ReadOptions.SearchDirection = BarcodeSearchDirection.Vertical; 
 
   // Even though this array will not contain all options, it should be enough to read all barcodes, since the version of ReadBarcodes we will use 
   // will use the default options if an overridden is not passed 
   BarcodeReadOptions[] readOptions = 
   { 
   oneDReadOptions, fourStateReadOptions, postNetPlanetReadOptions, gs1StackedReadOptions, patchCodeReadOptions, pdf417ReadOptions, microPdf417ReadOptions 
 }; 
 
   return readOptions; 
} 
 
 
 
static class LEAD_VARS 
{ 
   public const string ImagesDir = @"C:\LEADTOOLS22\Resources\Images"; 
}